#ifndef PROCESSINGSETTINGS_H
#define PROCESSINGSETTINGS_H

#include <QString>
#include <QFont>
#include <QColor>
#include <QStringList>
#include <QJsonDocument>
#include <QJsonObject>
#include "outputsettings.h"  // 继承现有设置
#include "pagepositionsystem.h"  // 统一的位置系统
#include "gridpagenumbersystem.h"  // 3×3网格调节系统
#include "pagenumberformatter.h"  // Martin Fowler重构：页码格式化器

/**
 * ProcessingSettings - 扩展的处理设置
 * 基于现有 OutputSettings，增加页码和 DPI 控制
 */
struct ProcessingSettings {
    // DPI设置
    int standardDPI = 150;
    bool autoOptimizeLargeDocuments = false;  // 默认关闭，保证高质量

    // 页边距设置（毫米）
    struct MarginSettings {
        double top = 20.0;
        double bottom = 20.0;
        double left = 15.0;
        double right = 15.0;

        MarginSettings() = default;

        QString toString() const {
            return QString("T%1_B%2_L%3_R%4").arg(top).arg(bottom).arg(left).arg(right);
        }
    } margins;

    // 页码设置
    struct PageNumberSettings {
        bool enabled = false;
        PagePositionSystem::Position position = PagePositionSystem::getDefaultPosition();
        QString format = "{page}";  // 默认格式，支持占位符
        bool showOnCover = false;
        int startNumber = 1;
        QFont font = QFont("SF Pro Display", 10);  // 使用系统字体，默认10pt符合印刷标准
        QColor color = Qt::black;

        // 新的3×3网格调节系统 - Martin Fowler重构：替代复杂偏移机制
        GridPageNumberSystem::GridState gridState;  // 网格状态，替代复杂的偏移计算

        // 保留的视觉效果属性
        double rotation = 0.0;        // 旋转角度
        double opacity = 1.0;         // 透明度 (0.0-1.0)
        double letterSpacing = 0.0;   // 字符间距
        double lineSpacing = 1.0;     // 行间距

        // 预设字体大小选项（符合印刷行业标准）
        static QList<int> getPresetFontSizes() {
            return {6, 8, 10, 12, 14, 16, 18};  // 6pt最小（印刷底线），18pt最大（页码上限）
        }

        // 预设字体家族
        static QStringList getPresetFontFamilies() {
            return {
                "SF Pro Display",
                "Helvetica Neue",
                "Arial",
                "Times New Roman",
                "PingFang SC",
                "Microsoft YaHei"
            };
        }

        PageNumberSettings() = default;

        // Martin Fowler重构：使用PageNumberFormatter替代重复代码
        // 预设格式选项 - 委托给PageNumberFormatter
        static QStringList getPresetFormats() {
            return PageNumberFormatter::getPresetFormats();
        }

        // 格式化页码文本 - 使用新的PageNumberFormatter（只使用全局页码）
        QString formatPageNumber(int globalPage, int totalPages) const {
            PageNumberFormatter::FormatContext context(globalPage, totalPages, format);
            return PageNumberFormatter::format(context);
        }

        // 获取格式化预览文本（用于UI预览）
        QString getFormatPreview(int samplePage = 1, int sampleTotal = 10) const {
            return formatPageNumber(samplePage, sampleTotal);
        }

        // 验证格式是否有效
        bool isValidFormat() const {
            return PageNumberFormatter::isValidFormat(format);
        }

        // 获取格式描述
        QString getFormatDescription() const {
            return PageNumberFormatter::getFormatDescription(format);
        }
    } pageNumber;

    // 继承现有设置
    HeaderFooterSettings header;
    HeaderFooterSettings footer;
    CoverPageSettings coverPage;

    // 模板名称
    QString templateName = "默认设置";

    ProcessingSettings() = default;

    // 边距预设管理
    enum class MarginPreset {
        Zero,           // 零边距（模拟无边距打印）
        Minimal,        // 最小边距（模拟激光打印机物理限制）
        Narrow,         // 窄边距
        Standard,       // 标准边距
        Wide,           // 宽边距
        Academic,       // 学术标准
        Print           // 打印优化
    };

    static MarginSettings getMarginPreset(MarginPreset preset) {
        switch (preset) {
            case MarginPreset::Zero:
                // 真正的零边距 - 完全模拟无边距打印机行为
                return {0.0, 0.0, 0.0, 0.0};
                
            case MarginPreset::Minimal:
                // 最小边距 - 模拟激光打印机的物理限制（约4mm）
                return {4.0, 4.0, 4.0, 4.0};
                
            case MarginPreset::Narrow:
                // 窄边距 - 适合网络分享和屏幕阅读
                return {10.0, 10.0, 10.0, 10.0};
                
            case MarginPreset::Standard:
                // 标准边距 - 通用文档格式
                return {20.0, 20.0, 15.0, 15.0};
                
            case MarginPreset::Wide:
                // 宽边距 - 适合打印和装订
                return {30.0, 30.0, 25.0, 25.0};
                
            case MarginPreset::Academic:
                // 学术标准 - 符合学术论文格式要求
                return {25.0, 25.0, 25.0, 25.0};
                
            case MarginPreset::Print:
                // 打印优化 - 考虑打印机特性的边距
                return {25.0, 25.0, 20.0, 20.0};
                
            default:
                return {20.0, 20.0, 15.0, 15.0};
        }
    }

    static QStringList getMarginPresetNames() {
        return QStringList{
            "零边距 (0mm)",      // Zero - 完全无边距
            "最小边距 (4mm)",    // Minimal - 激光打印机物理限制
            "窄边距 (10mm)",     // Narrow - 网络分享
            "标准边距 (20mm)",   // Standard - 通用文档
            "宽边距 (30mm)",     // Wide - 打印装订
            "学术标准 (25mm)",   // Academic - 学术论文
            "打印优化 (25mm)"    // Print - 打印机优化
        };
    }

    static QString getMarginPresetDescription(MarginPreset preset) {
        switch (preset) {
            case MarginPreset::Zero:
                return "完全无边距，内容占满整个页面（模拟无边距打印机）";
            case MarginPreset::Minimal:
                return "最小物理边距，模拟激光打印机的硬件限制";
            case MarginPreset::Narrow:
                return "窄边距，适合网络分享和屏幕阅读";
            case MarginPreset::Standard:
                return "标准边距，适合大多数文档类型";
            case MarginPreset::Wide:
                return "宽边距，适合打印和装订";
            case MarginPreset::Academic:
                return "学术标准边距，符合论文格式要求";
            case MarginPreset::Print:
                return "打印优化边距，考虑打印机特性";
            default:
                return "标准边距";
        }
    }

    // 预设管理
    static ProcessingSettings getPreset(const QString& presetName) {
        ProcessingSettings settings;

        if (presetName == "网络分享") {
            settings.standardDPI = 96;
            settings.margins = getMarginPreset(MarginPreset::Narrow);
            settings.pageNumber.enabled = false;
            settings.templateName = "网络分享";
        }
        else if (presetName == "打印质量") {
            settings.standardDPI = 300;
            settings.margins = getMarginPreset(MarginPreset::Print);
            settings.pageNumber.enabled = true;
            settings.pageNumber.format = "{page}";
            settings.templateName = "打印质量";
        }
        else if (presetName == "学术论文") {
            settings.standardDPI = 150;
            settings.margins = getMarginPreset(MarginPreset::Academic);
            settings.pageNumber.enabled = true;
            settings.pageNumber.format = "- {page} -";
            settings.pageNumber.position = PagePositionSystem::Position::BottomCenter;
            settings.templateName = "学术论文";
        }
        else if (presetName == "商务报告") {
            settings.standardDPI = 150;
            settings.margins = getMarginPreset(MarginPreset::Standard);
            settings.pageNumber.enabled = true;
            settings.pageNumber.format = "第{page}页";
            settings.pageNumber.position = PagePositionSystem::Position::BottomRight;
            settings.templateName = "商务报告";
        }
        else if (presetName == "无边距打印") {
            settings.standardDPI = 150;
            settings.margins = getMarginPreset(MarginPreset::Zero);
            settings.pageNumber.enabled = false;  // 零边距时通常不显示页码
            settings.templateName = "无边距打印";
        }
        else {
            // 标准文档（默认）
            settings.standardDPI = 150;
            settings.margins = getMarginPreset(MarginPreset::Standard);
            settings.pageNumber.enabled = true;
            settings.pageNumber.format = "{page}";
            settings.templateName = "标准文档";
        }

        return settings;
    }

    static QStringList getAvailablePresets() {
        return QStringList{
            "标准文档",
            "网络分享",
            "打印质量",
            "学术论文",
            "商务报告"
        };
    }

    void saveAsPreset(const QString& name) {
        templateName = name;
        // TODO: 实现预设保存到配置文件
    }

    // 序列化支持
    QString toJsonString() const {
        QJsonObject json;
        json["standardDPI"] = standardDPI;
        json["autoOptimizeLargeDocuments"] = autoOptimizeLargeDocuments;
        json["templateName"] = templateName;

        // 页边距
        QJsonObject marginsJson;
        marginsJson["top"] = margins.top;
        marginsJson["bottom"] = margins.bottom;
        marginsJson["left"] = margins.left;
        marginsJson["right"] = margins.right;
        json["margins"] = marginsJson;

        // 页码设置
        QJsonObject pageNumberJson;
        pageNumberJson["enabled"] = pageNumber.enabled;
        pageNumberJson["position"] = static_cast<int>(pageNumber.position);
        pageNumberJson["format"] = pageNumber.format;
        pageNumberJson["showOnCover"] = pageNumber.showOnCover;
        pageNumberJson["startNumber"] = pageNumber.startNumber;

        // 新的网格状态序列化
        QJsonObject gridStateJson;
        gridStateJson["horizontalStep"] = static_cast<int>(pageNumber.gridState.horizontalStep);
        gridStateJson["verticalStep"] = static_cast<int>(pageNumber.gridState.verticalStep);
        pageNumberJson["gridState"] = gridStateJson;

        json["pageNumber"] = pageNumberJson;

        QJsonDocument doc(json);
        return doc.toJson(QJsonDocument::Compact);
    }

    bool fromJsonString(const QString& json) {
        QJsonParseError error;
        QJsonDocument doc = QJsonDocument::fromJson(json.toUtf8(), &error);

        if (error.error != QJsonParseError::NoError) {
            return false;
        }

        QJsonObject jsonObj = doc.object();

        standardDPI = jsonObj.value("standardDPI").toInt(150);
        autoOptimizeLargeDocuments = jsonObj.value("autoOptimizeLargeDocuments").toBool(false);
        templateName = jsonObj.value("templateName").toString("默认设置");

        // 页边距
        if (jsonObj.contains("margins")) {
            QJsonObject marginsJson = jsonObj.value("margins").toObject();
            margins.top = marginsJson.value("top").toDouble(20.0);
            margins.bottom = marginsJson.value("bottom").toDouble(20.0);
            margins.left = marginsJson.value("left").toDouble(15.0);
            margins.right = marginsJson.value("right").toDouble(15.0);
        }

        // 页码设置
        if (jsonObj.contains("pageNumber")) {
            QJsonObject pageNumberJson = jsonObj.value("pageNumber").toObject();
            pageNumber.enabled = pageNumberJson.value("enabled").toBool(false);
            pageNumber.position = static_cast<PagePositionSystem::Position>(
                pageNumberJson.value("position").toInt(static_cast<int>(PagePositionSystem::getDefaultPosition())));
            pageNumber.format = pageNumberJson.value("format").toString("{page}");
            pageNumber.showOnCover = pageNumberJson.value("showOnCover").toBool(false);
            pageNumber.startNumber = pageNumberJson.value("startNumber").toInt(1);

            // 网格状态反序列化（fromJsonString版本）
            if (pageNumberJson.contains("gridState")) {
                QJsonObject gridStateJson = pageNumberJson.value("gridState").toObject();
                pageNumber.gridState.horizontalStep = static_cast<GridPageNumberSystem::GridStep>(
                    gridStateJson.value("horizontalStep").toInt(0));
                pageNumber.gridState.verticalStep = static_cast<GridPageNumberSystem::GridStep>(
                    gridStateJson.value("verticalStep").toInt(0));
            }
        }

        return true;
    }

    // 便利方法：获取DPI描述文本
    QString getDPIDescription() const {
        if (standardDPI <= 96) return "网络分享质量";
        else if (standardDPI <= 150) return "标准质量";
        else if (standardDPI <= 300) return "打印质量";
        else return "出版级质量";
    }

    // Martin Fowler重构：Replace Algorithm - 基于实际测试的PDF大小预估算法
    QString getEstimatedFileSize(int pageCount = 1) const {
        // 基于实际测试数据的更准确PDF大小预估

        // 1. 计算单页图像的理论大小（A4页面像素数）
        double a4WidthPx = 210.0 / 25.4 * standardDPI;   // A4宽度像素
        double a4HeightPx = 297.0 / 25.4 * standardDPI;  // A4高度像素
        double pixelsPerPage = a4WidthPx * a4HeightPx;

        // 2. 原始图像大小估算（24位RGB）
        double rawImageSizeMB = (pixelsPerPage * 3) / (1024.0 * 1024.0);

        // 3. 基于实际测试的PDF压缩因子（更保守的估算）
        double compressionFactor;
        if (standardDPI >= 600) compressionFactor = 0.08; // 超高DPI：8%压缩率
        else if (standardDPI >= 300) compressionFactor = 0.06; // 高DPI：6%压缩率（实际测试300DPI约5-7%）
        else if (standardDPI >= 150) compressionFactor = 0.05; // 中DPI：5%压缩率
        else compressionFactor = 0.04; // 低DPI：4%压缩率

        // 4. 考虑内容区域优化（实际渲染时不是全A4像素）
        double contentAreaFactor = 0.85; // 内容区域通常占A4的85%左右

        // 5. 单页压缩后大小
        double compressedPageMB = rawImageSizeMB * compressionFactor * contentAreaFactor;

        // 6. PDF开销（文件头、页码、边距等固定成本）
        double pdfOverheadMB = 0.02 + (pageCount * 0.005); // 20KB基础 + 每页5KB开销

        // 7. 总大小计算
        double totalMB = (compressedPageMB * pageCount) + pdfOverheadMB;

        // 8. 格式化输出
        if (totalMB < 1.0) {
            return QString("%1 KB").arg((int)(totalMB * 1024));
        } else if (totalMB < 1000.0) {
            return QString("%1 MB").arg(totalMB, 0, 'f', 1);
        } else {
            return QString("%1 GB").arg(totalMB / 1024.0, 0, 'f', 2);
        }
    }
    
    // 新增：QJsonObject 序列化支持（用于预设管理）
    QJsonObject toJsonObject() const {
        QJsonObject json;
        json["standardDPI"] = standardDPI;
        json["autoOptimizeLargeDocuments"] = autoOptimizeLargeDocuments;
        json["templateName"] = templateName;

        // 页边距
        QJsonObject marginsJson;
        marginsJson["top"] = margins.top;
        marginsJson["bottom"] = margins.bottom;
        marginsJson["left"] = margins.left;
        marginsJson["right"] = margins.right;
        json["margins"] = marginsJson;

        // 页码设置
        QJsonObject pageNumberJson;
        pageNumberJson["enabled"] = pageNumber.enabled;
        pageNumberJson["position"] = static_cast<int>(pageNumber.position);
        pageNumberJson["format"] = pageNumber.format;
        pageNumberJson["showOnCover"] = pageNumber.showOnCover;
        pageNumberJson["startNumber"] = pageNumber.startNumber;

        // 新的网格状态序列化（QJsonObject版本）
        QJsonObject gridStateJson;
        gridStateJson["horizontalStep"] = static_cast<int>(pageNumber.gridState.horizontalStep);
        gridStateJson["verticalStep"] = static_cast<int>(pageNumber.gridState.verticalStep);
        pageNumberJson["gridState"] = gridStateJson;

        // 字体信息序列化 - 分别保存各个属性
        pageNumberJson["fontFamily"] = pageNumber.font.family();
        pageNumberJson["fontSize"] = pageNumber.font.pointSize();
        pageNumberJson["fontBold"] = pageNumber.font.bold();
        pageNumberJson["fontItalic"] = pageNumber.font.italic();
        pageNumberJson["color"] = pageNumber.color.name();

        json["pageNumber"] = pageNumberJson;

        return json;
    }
    
    bool fromJsonObject(const QJsonObject& jsonObj) {
        standardDPI = jsonObj.value("standardDPI").toInt(150);
        autoOptimizeLargeDocuments = jsonObj.value("autoOptimizeLargeDocuments").toBool(false);
        templateName = jsonObj.value("templateName").toString("默认设置");

        // 页边距
        if (jsonObj.contains("margins")) {
            QJsonObject marginsJson = jsonObj.value("margins").toObject();
            margins.top = marginsJson.value("top").toDouble(20.0);
            margins.bottom = marginsJson.value("bottom").toDouble(20.0);
            margins.left = marginsJson.value("left").toDouble(15.0);
            margins.right = marginsJson.value("right").toDouble(15.0);
        }

        // 页码设置
        if (jsonObj.contains("pageNumber")) {
            QJsonObject pageNumberJson = jsonObj.value("pageNumber").toObject();
            pageNumber.enabled = pageNumberJson.value("enabled").toBool(false);
            pageNumber.position = static_cast<PagePositionSystem::Position>(
                pageNumberJson.value("position").toInt(static_cast<int>(PagePositionSystem::getDefaultPosition())));
            pageNumber.format = pageNumberJson.value("format").toString("{page}");
            pageNumber.showOnCover = pageNumberJson.value("showOnCover").toBool(false);
            pageNumber.startNumber = pageNumberJson.value("startNumber").toInt(1);

            // 网格状态反序列化（fromJsonObject版本）
            if (pageNumberJson.contains("gridState")) {
                QJsonObject gridStateJson = pageNumberJson.value("gridState").toObject();
                pageNumber.gridState.horizontalStep = static_cast<GridPageNumberSystem::GridStep>(
                    gridStateJson.value("horizontalStep").toInt(0));
                pageNumber.gridState.verticalStep = static_cast<GridPageNumberSystem::GridStep>(
                    gridStateJson.value("verticalStep").toInt(0));
            }

            // 字体信息反序列化 - 分别读取各个属性
            if (pageNumberJson.contains("fontFamily")) {
                pageNumber.font.setFamily(pageNumberJson.value("fontFamily").toString());
            }
            if (pageNumberJson.contains("fontSize")) {
                pageNumber.font.setPointSize(pageNumberJson.value("fontSize").toInt());
            }
            if (pageNumberJson.contains("fontBold")) {
                pageNumber.font.setBold(pageNumberJson.value("fontBold").toBool());
            }
            if (pageNumberJson.contains("fontItalic")) {
                pageNumber.font.setItalic(pageNumberJson.value("fontItalic").toBool());
            }
            if (pageNumberJson.contains("color")) {
                pageNumber.color = QColor(pageNumberJson.value("color").toString());
            }
        }

        return true;
    }
};

#endif // PROCESSINGSETTINGS_H